package main.java.study.datastructure.queue;

import java.util.Queue;

/**
 * <p>环形队列</p>
 *
 * @author LiShaoWen
 * @date 2021/10/14 21:53
 */
public class CircleQueueDemo {
    class CirCleQueue {
        private int[] array;
        // 指向队列尾部元素的后一个位置，实际上就是预留的一个空位,空位是动态变化的，插入元素时空位向后移动一位（预留空位主要是为了方便判空和判满）
        private int rear;
        // 指向队列头，默认为0
        private int front;
        private int maxSize;

        public CirCleQueue(int arrayMaxSize) {
            maxSize = arrayMaxSize;
            array = new int[arrayMaxSize];
        }

        public boolean isFull() {
            // rear的下一个位置为front时为满
            return (rear+1)%maxSize==front;
        }

        public boolean isEmpty() {
            // rear和front重合时为空
            return rear == front;
        }

        public void add(int n) {
            if (isFull()) {
                System.out.println("对列已满");
                return;
            }
            array[rear] = n;
            // 空位是动态变化的，插入元素时空位向后移动一位
            rear = (rear+1)%maxSize;
        }

        public int get() {
            if (isEmpty()) {
                throw new RuntimeException("对列空");
            }
            int result = array[front];
            front = (front+1)%maxSize;
            return result;
        }

        public void show(){
            // 从front开始遍历
            for (int i=front;i<front+size();i=(i+1)%maxSize){
                System.out.println(String.format("a[%d]=%d",i,array[i]));
            }
        }

        /**
         * 环形队列的元素个数
         * @author lishaowen
         * @date 2021/10/14 22:46
         * @return int
         */
        public int size(){
            // 加maxSize是因为有时候rear小于front
            return (rear-front+maxSize)%maxSize;
        }

        public int head() {
            if (isEmpty()) {
                throw new RuntimeException("对列空");
            }
            return array[front];
        }

    }
}
